DOIT

Dynamic Object Language Labs' (DOLL) Object Intelligent Tools (DOIT) includes an inference engine that supports forward and backward chaining, a truth maintenance facility, and graphical rule debugging aids. The inference engine is implemented as C++ class libraries that can be integrated with C++ programs.

The environment comes with a built-in persistent storage mechanism. It can also be configured to operate as a part of an ObjectStore application, where ObjectStore is an OODB from ODI.

The chief advantage of DOLL's inference engine is that it is tightly integrated with the overall C++ application - in fact, it utilizes the application's objects directly.

DOLL's engine allows adding inferencing capability to an existing data model without changing or making a copy of that data model. The inference rules are added to the system, and data objects inherit from the working memory element class, but the data model stays the same.

Why is this important? The inference engine allows the programmer to eliminate the following problems with using other inference products :

translation cost

with other products, objects used in the inference engine must be converted to the format acceptable to inference engine.
Implication:
unacceptable performance, the objects actually manipulated by the inference engine are not available to the programmer.

application complexity

keeping two sets of application objects in synch for object creation and modification.
Implication: unacceptable performance, large footprint, loss of referential integrity.

development complexity

integrating a C++ application with a foreign inference engine module
Implication:
have to use additional development and debugging tools, maintenance of keeping two schemas in synch, developing with two identical schemas represented in different languages.

Limited extensibility

extending the existing model is more difficult.
Implication:
short life-span of the system, limited feature set.

The engine also presents other benefits beyond just removing limitations of existing systems, based on all rules and actions compiling to C++, on DOIT's unique multiple rule contexts, and on DOIT's unique truth maintenance system:

1. in-memory performance of rule processing with compiled rules.
   Implication : keeps up with the rest of the system
   
2. rules, actions in C++ source code
   Implication : can debug with existing C++ debuggers
   
3. extensibility by C++ inheritance
   Implication : can extend system in a safe, predictable manner
   
4. utilities and tools designed by C++ developers for C++ developers
   Implication : reduced development cycle, reliable applications
   
5. multiple rule contexts, with private rule set and working memory, reduces complexity
   Implication : improved performance and robustness
   
6. truth maintenance facility tracks and fixes changes to data support relations
   Implication: much lower complexity of system
   
7. truth maintenance operates within a single rule system cycle
   Implication: much faster performance

Expert systems store significant amounts of knowledge as objects which have significant structural relationship to other knowledge objects, and which are woven into further complex structures. It is expensive and error prone to recompute such structures on application invocation, so there is a tremendous advantage in using persistent storage via ObjectStore.

ObjectStore tools allow for better support for debugging during application development than systems based on proprietary knowledge storage mechanisms. Most systems force the user to debug their systems with "black box" rule debuggers, whereas the DOIT tools recognize that the expert system component is just a part of bigger whole, and users can use standard C++ debuggers, Object store database tools, and DOIT rule debugger as appropriate.

Since DOIT and ObjectStore both work with standard C++ objects, it is easy to integrate and extend the DOIT tools into existing C++ code. Whereas most tools on the market have the inference engine in a 'black box', the DOIT tools allow users to define their own objects as C++ classes and even extend the semantics of the inference engine. This allows for more efficient applications, and better use of storage.

A major networking company has used DOLL's inference engine to implement software for configuring networks. Network management is a significant task as networks grow in size to thousands or tens of thousands of nodes for some organizations. Better tools are required to do network management and configuration. This task is ideally suited for expert system technology, because:

• Networks are configured today by experts who utilize informal rules and heuristics,
  
  
• Network configuration is a fast changing technology area
  
  
• Current technology is already oriented toward declarative description of network configuration

Crucial to their decision to utilize DOLL's inference engine tools were:

1. They needed tools that could interface easily with C++ and their Object Store based application
   
2. They needed excellent performance.
   
3. They wanted to utilize truth maintenance technology to cut the number of rules required for their system by one half.
   
4. They wanted to manage the utilization of working memory data objects by the inference engine themselves.
   
5. They wanted to take advantage of another unique DOIT feature, multiple contexts, which allows better control of complexity and better performance.
   
6. Use of DOLL's DOIT technology allowed them to reduce their time to market, and increase the feature set of their initial application.

For further technical details, see:

Technical Overview of DOLL Inference Engine

For further information about AI applications, see:

Artificial Intelligence in Application

In addition to the inference engine libraries, DOLL can provide expert consultation on the design and implementation of rule based software. We have successfully worked with customers to develop applications utilizing expert system technology, in areas such as planning, scheduling, design, layout, configuration, diagnosis, and image recognition. The applications have included defense systems, communications software, networking software, financial systems, industrial and process control software. Companies starting out with expert system and object oriented programming can utilize our tools, and also utilize our expertise as a bridge to cover the transition from beginning a project, to staffing up and fielding multiple applications.

DOLL also provides training courses in the design and implementation of expert systems, as well as courses in the use of DOIT. DOLL can provide AI training and consulting in areas other than expert systems as well, including applications of genetic algorithms and intelligent tutoring.

To inquiry about consulting possibilities and rates, contact:

Paul Robertson

Phone: (508) 372 7635

Fax: (508) 475 7312

Email: rladdaga@doll.com

DOLL Home Page